Dynamic editors for functionally composed ui

ABSTRACT

Embodiments include presenting a first user interface (UI) of an executing application, based on model data that defines an appearance of UI elements of the first UI. Concurrent to presenting the first UI, a second UI of a real-time editor is presented. The second UI is configured to receive editing inputs that are to be applied to the model data, to edit the first UI while the application is executing. A first editing input is received at the second UI, which selects particular model data defining particular UI element(s). Based on the first editing input at the second UI, each of the particular UI element(s) is visually distinguished within the first UI. A second editing input is received at the second UI, which provides changes to the model data corresponding to the particular UI element(s). The particular UI element(s) of the first UI are updated to reflect the desired changes.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.12/637,353, filed Dec. 14, 2009, and entitled “DYNAMIC EDITORS FORFUNCTIONALLY COMPOSED UI,” which application claims priority to U.S.Provisional Patent Application Ser. No. 61/261,701, filed Nov. 16, 2009and entitled “DYNAMIC EDITORS FOR FUNCTIONALLY COMPOSED UI.” The entirecontents of the foregoing applications are incorporated by referenceherein in their entirety.

BACKGROUND

Computers have become highly integrated in the workforce, in the home,in mobile devices, and many other places. Computers can process massiveamounts of information quickly and efficiently. Software applicationsdesigned to run on computer systems allow users to perform a widevariety of functions including business applications, schoolwork,entertainment and more. Software applications are often designed toperform specific tasks, such as word processor applications for draftingdocuments, or email programs for sending, receiving and organizingemail.

In many cases, software applications are designed to interact with oreven design other software applications. For instance, integrateddevelopment environments can be used by developers to write and debugsoftware applications. Some of these environments are specialized fordesigning software application user interfaces. These specialized userinterface designers are often configured to provide awhat-you-see-is-what-you-get (WYSIWYG) design experience. Using such adesigner, a developer may simply drag and drop user interface (UI)elements onto the UI that is being designed, and the specialized UIdesigner application will write the software code corresponding to theuser's drag and drop actions.

BRIEF SUMMARY

The present invention extends to methods, systems, and computer programproducts for providing a real-time incremental editor for enactingchanges on a user interface (UI) and presenting a preview of thepotential results of a user edit to data model data.

Embodiments include presenting a first user interface (UI) of anexecuting application program based on a UI model that includesdeclarative model data that drives the behavior of the first UI. The UImodel includes particular declarative model data that declarativelydefines a visual appearance of one or more UI elements of the first UI.Each of the UI element(s) is an instance of the particular declarativemodel data.

Concurrent to presenting the first UI, a second UI of a real-timeincremental editor is presented. The second UI is separate from theapplication program and is configured to receive one or more editinginputs that are to be applied to the particular declarative model dataof the UI model, to edit the first UI while the application program isexecuting.

A first editing user input is received at the second UI. The firstediting input selects the particular declarative model data thatdeclaratively defines the UI element(s). Based on selection of theparticular declarative model data within the real-time incrementaleditor, each of the UI element(s) is visually distinguished within thefirst UI as being selected at the second UI of the real-time incrementaleditor.

A second editing user input is received at the second UI of thereal-time incremental editor. The second editing user input provides oneor more changes to the particular declarative model data correspondingto the UI element(s), in order to enact one or more desired edits toeach of the UI element(s). The first UI is updated to reflect thedesired edits to the UI element(s), including altering the visualappearance of each of the UI element(s) based on the changes to theparticular declarative model data corresponding to the UI element(s).

This summary is provided to introduce a selection of concepts in asimplified form that are further described below in the DetailedDescription. This Summary is not intended to identify key features oressential features of the claimed subject matter, nor is it intended tobe used as an aid in determining the scope of the claimed subjectmatter.

Additional features and advantages of the invention will be set forth inthe description which follows, and in part will be obvious from thedescription, or may be learned by the practice of the invention. Thefeatures and advantages of the invention may be realized and obtained bymeans of the instruments and combinations particularly pointed out inthe appended claims. These and other features of the present inventionwill become more fully apparent from the following description andappended claims, or may be learned by the practice of the invention asset forth hereinafter.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and otheradvantages and features of the invention can be obtained, a moreparticular description of the invention briefly described above will berendered by reference to specific embodiments thereof which areillustrated in the appended drawings. Understanding that these drawingsdepict only typical embodiments of the invention and are not thereforeto be considered to be limiting of its scope, the invention will bedescribed and explained with additional specificity and detail throughthe use of the accompanying drawings in which:

FIG. 1 illustrates a computer architecture in which embodiments of thepresent invention may operate including providing a real-timeincremental editor for enacting changes on a user interface (UI) andpresenting a preview of the potential results of a user edit to datamodel data.

FIG. 2 illustrates a flowchart of an example method for providing areal-time incremental editor for enacting changes on a user interface(UI).

FIG. 3 illustrates a flowchart of an example method for presenting apreview of the potential results of a user edit to data model data.

FIG. 4 illustrates an embodiment of the present invention in which a UIis dynamically updated.

FIG. 5 illustrates an embodiment of the present invention in whichselected elements are highlighted in a running application

DETAILED DESCRIPTION

The present invention extends to methods, systems, and computer programproducts for providing a real-time incremental editor for enactingchanges on a user interface (UI) and presenting a preview of thepotential results of a user edit to data model data. A computer systeminstantiates a real-time incremental editor configured to receiveediting inputs that are to be applied to data of a data model, where thedata model data declaratively defines a UI model that drives thebehavior of a corresponding UI based on the UI model. The computersystem receives an editing input from a user indicating one or moredesired edits that are to be made to the UI and determines, based on thereceived editing inputs, which changes are to be made to the data modeldata to enact the desired changes in the UI. The computer system updatesthe UI in real-time based on the determined edits to the data model dataand presents the updated UI in real-time without losing stateinformation in the resultant UI.

In another embodiment, a computer system instantiates a real-timeincremental editor configured to receive editing inputs that are to beapplied to data of a data model, where the data model data declarativelydefines a UI model that drives the behavior of a corresponding UI basedon the UI model. The computer system receives an input from a user atthe instantiated editor, where the input indicates various edits thatare to be applied to a running software application. The computer systemdetermines, based on the received user input, which changes are to bemade to the data model data to enact the desired changes in the runningsoftware application and previews the determined changes in real-time onthe running application.

Embodiments of the present invention may comprise or utilize a specialpurpose or general-purpose computer including computer hardware, suchas, for example, one or more processors and system memory, as discussedin greater detail below. Embodiments within the scope of the presentinvention also include physical and other computer-readable media forcarrying or storing computer-executable instructions, computer programproducts and/or data structures. Such computer-readable media can be anyavailable media that can be accessed by a general purpose or specialpurpose computer system. Computer-readable media that storecomputer-executable instructions are physical storage media.Computer-readable media that carry computer-executable instructions aretransmission media. Thus, by way of example, and not limitation,embodiments of the invention can comprise at least two distinctlydifferent kinds of computer-readable media: computer storage media andtransmission media.

Computer storage media includes RAM, ROM, EEPROM, CD-ROM or otheroptical disk storage, magnetic disk storage or other magnetic storagedevices, or any other medium which can be used to store desired programcode means in the form of computer-executable instructions or datastructures and which can be accessed by a general purpose or specialpurpose computer.

A “network” is defined as one or more data links that enable thetransport of electronic data between computer systems and/or modulesand/or other electronic devices. When information is transferred orprovided over a network or another communications connection (eitherhardwired, wireless, or a combination of hardwired or wireless) to acomputer, the computer properly views the connection as a transmissionmedium. Transmissions media can include a network and/or data linkswhich can be used to carry or desired program code means in the form ofcomputer-executable instructions or data structures and which can beaccessed by a general purpose or special purpose computer. Combinationsof the above should also be included within the scope ofcomputer-readable media.

Further, upon reaching various computer system components, program codemeans in the form of computer-executable instructions or data structurescan be transferred automatically from transmission media to computerstorage media (or vice versa). For example, computer-executableinstructions or data structures received over a network or data link canbe buffered in RAM within a network interface module (e.g., a “NIC”),and then eventually transferred to computer system RAM and/or to lessvolatile computer storage media at a computer system. Thus, it should beunderstood that computer storage media can be included in computersystem components that also (or even primarily) utilize transmissionmedia.

Computer-executable instructions comprise, for example, instructions anddata which, when executed at a processor, cause a general purposecomputer, special purpose computer, or special purpose processing deviceto perform a certain function or group of functions. The computerexecutable instructions may be, for example, binaries, intermediateformat instructions such as assembly language, or even source code.Although the subject matter has been described in language specific tostructural features and/or methodological acts, it is to be understoodthat the subject matter defined in the appended claims is notnecessarily limited to the described features or acts described above.Rather, the described features and acts are disclosed as example formsof implementing the claims.

Those skilled in the art will appreciate that the invention may bepracticed in network computing environments with many types of computersystem configurations, including, personal computers, desktop computers,laptop computers, message processors, hand-held devices, multi-processorsystems, microprocessor-based or programmable consumer electronics,network PCs, minicomputers, mainframe computers, mobile telephones,PDAs, pagers, routers, switches, and the like. The invention may also bepracticed in distributed system environments where local and remotecomputer systems, which are linked (either by hardwired data links,wireless data links, or by a combination of hardwired and wireless datalinks) through a network, both perform tasks. In a distributed systemenvironment, program modules may be located in both local and remotememory storage devices.

FIG. 1 illustrates a computer architecture 100 in which the principlesof the present invention may be employed. Computer architecture 100includes editors A and B (110A and 110B, respectively). In someembodiments, only one editor may be used. In other embodiments, two ormore editors may be used. Editors, as used herein, may refer todevelopment environments in which a software developer may design orotherwise construct a software application or element thereof. Theeditors may comprise all different types of editors including texteditors, graphical editors (e.g. tree/diagram editors) and other typesof editors. The editors may provide a textual, graphical or otherrepresentation of a model. This model may be used as the basis for asoftware application (e.g. running application 135) or for the softwareapplication's user interface (111). Thus, in some cases, a developer mayuse an editor (e.g. 110A) to design or edit a model that forms the basisof user interface 111.

During UI development, the developer (or more generically, user 105) maydesire to make changes to the UI of running application 135. Thus, user105 provides editing inputs 106 which, when applied, will alter the UI.These editing inputs are received by the editor(s) and are processed todetermine which changes are to be made to the UI to bring about thedesired result. Here it should be noted that UI 111 may be a data-driveninterface. Accordingly, the UIs may have a UI model which is based on adata model (e.g. model 120). Such data-driven interfaces may be changedin real-time (or essentially real-time) by changing the data (121) ofthe data model (120). Thus, update determining module 115 may be used todetermine, based on the received determined changes 113 from the editor,which changes are to be made to the data to bring about the desiredchanges in the UI.

Update determining module 115 may also be configured to propagate anychanges or edits made to editor A (110A) by user 105 to editor B (110B),and vice versa. Thus, edits from editor B 116 may be propagated toeditor A and edits from editor A 117 may be propagated to editor B. Incases where other editors exist, edits may also be propagated to theother editors. The propagation of edits may occur because of a two-waybinding between the update determining module 115 (a data flow engine insome embodiments) and the editors.

Upon determining which data changes are to be made to data model 120,update determining module 115 may output the UI model updates 123 thatare to be made to the UI (111) of running application 135. Runtime modelinterpreter may receive the UI model updates and, in real-time, outputthe actual UI changes or updates 131 that are to be made to the UI.Thus, in this manner, UI 111 is updated dynamically, in real-time basedon the editing inputs provided by the user 105. The changes may beviewed within the editor as the UI is altered based on the runtime modelinterpreter's outputs. These steps will be explained in greater detailbelow with regard to methods 200 of FIGS. 2 and 300 of FIG. 3.

In view of the systems and architectures described above, methodologiesthat may be implemented in accordance with the disclosed subject matterwill be better appreciated with reference to the flow charts of FIGS. 2and 3. For purposes of simplicity of explanation, the methodologies areshown and described as a series of blocks. However, it should beunderstood and appreciated that the claimed subject matter is notlimited by the order of the blocks, as some blocks may occur indifferent orders and/or concurrently with other blocks from what isdepicted and described herein. Moreover, not all illustrated blocks maybe required to implement the methodologies described hereinafter.

FIG. 2 illustrates a flowchart of a method 200 for providing a real-timeincremental editor for enacting changes on a user interface (UI). Themethod 200 will now be described with frequent reference to thecomponents and data of environments 100 of FIGS. 1 and 400 of FIG. 4.

Method 200 includes an act of instantiating a real-time incrementaleditor configured to receive editing inputs that are to be applied todata of a data model, wherein the data model data declaratively definesa UI model that drives the behavior of a corresponding UI based on theUI model (act 210). For example, a computer system may instantiatereal-time incremental editor 110A which is configured to receive editinginputs 106 that are to be applied to data 121 of data model 120. Datamodel data 121 declaratively defines a UI model that drives the behaviorof UI 111 which is based on the UI model. As used herein, declarativelydefining a model refers to allowing the user to design or specify themodel using data, and not rigid logic. That data can then be analyzedand interpreted in real-time without needing to be compiled first.Accordingly, by having data model data 121 that declaratively defines amodel, simple changes to the data model data can be applied in real-timewithout having to recompile or even stop a running software applicationthat is based on the data model.

In some cases, data model 120 may be structured according to a schema.This may be referred to herein as a schematized model. Data model 120may include many different types of data. This data may be stored in alocal data store or may be stored remotely, perhaps even on a number ofdifferent computer systems such as on a storage area network (SAN). Insome embodiments, data model data 121 may be divided into chunks. Thesechunks may be based on corresponding portions of a UI tree. Forinstance, a UI tree that has multiple different elements as part of thetree, may have a chunk of data corresponding to each element of thetree. In some cases, these chunks may comprise text chunks. The textchunks may be structured such that data model (schema) grammar thatdefines how the data 121 is to be structured is not violated.Accordingly, in such cases, bad or improperly functioning states may beavoided as the text chunks are structured in such a way as to preventschema grammar violations.

In cases where data model data 121 is divided into text chunks, atwo-way data binding may be applied between a textual editor view andthe text chunks of the data model data, such that any edits to the datamodel data cause the textual editor to update automatically.Accordingly, in instances where editor A is a textual editor, editor Amay have a two-way data binding between itself and the text chunks ofthe data model data 121. In such cases, any edits made to data modeldata 121 (e.g. as a result of editing inputs 106) cause the textualeditor (editor A) to update automatically.

Method 200 includes an act of receiving an editing input from a userindicating one or more desired edits that are to be made to the UI (act220). For example, editor A (110A) may receive editing input 106 fromuser 105 indicating one or more desired edits that are to be made to theUI. These edits may comprise text edits, graphical edits or any othertype of changes or modifications that can be made to UI 111. Editor Amay be configured to output determined changes 113 indicating theeditor's interpretation of the user's editing inputs. For instance, ifuser 105 indicates in editing input 106 that a diagram element is to bechanged, the editor may identify in changes 113 which element is to bechanged. Thus, if the diagram element is to be moved, the editor wouldidentify the current position of the element and the new (moved)position of the element. This is one example among many, many differentchanges that can be made. Accordingly, the example is intended merely toillustrate how changes 113 may be generated and should not be read aslimiting the type or number or style of changes that can be made.

Method 200 also includes an act of determining, based on the receivedediting inputs, which changes are to be made to the data model data toenact the desired changes in the UI (act 230). For example, updatedetermining module 115 may determine, based on received editing inputs106 (and/or determined changes 113), which UI model updates 123 are tobe made to data model data 121 (upon which UI 111 is built) to enact thedesired changes in the UI. These UI model updates may comprise, forexample, an indication of which elements are to be changed and by howmuch.

The UI model updates 123 may, at least in some cases, be transformedinto UI changes using purely functional transformations. Because the UIis data-driven, data model data 121 may be changed in a purelyfunctional transformation, without recompiling the UI or even stoppingit to make the changes. In some embodiments, the UI model updates 123indicating how the data model data 121 is to be transformed into UIchanges 131 are data and can be changed, manipulated or transferred inthe same way data is normally handled. Moreover, the data indicating howthe data model data 121 is to be transformed into UI changes 131 may bemapped to a structured UI representation including text, a UI tree, agraphical diagram or any other type of structured UI representation.

In some embodiments, update determining module 115 may comprise a dataflow engine. A data flow engine, as used herein, may refer to a softwareengine that supports functional composition and the use of queries forproperty-binding, repeated object construction, and conditional objectconstruction. The data flow engine may be configured to receive andprocess functional application descriptions based on models. Forinstance, the data flow engine may be configured to process extensiblemarkup language (XML) application foundation (XAF) applications or otherfunctional application descriptions. Additionally or alternatively, thedata flow engine may be configured to process queries constructed by theeditors.

XAF, as used herein, is a software application framework for generatinga runtime structure for a given software application and for managingexecution of the software application. Applications may be generated byan application framework that includes a collection or graph ofconnected application components. Functionalities of an applicationconfigured according to the application framework are enabled bydynamically configuring groups of application components into componentdomains where each domain is configured to enable a given functionalityof the application, for example, displaying a picture in a wordprocessing document.

In order to generate a runtime structure for the application, anapplication may pass an application description for each piece ofapplication functionality to an application description engine. Theapplication description provides declarative rules for structuring andcomposing the component domains, and the application description engineis operative to interpret the declarative rules for creating andreconfiguring the component domains as required based on data eventsreceived by the application. Data events, as used herein, may be anytype of software message, user input, or other indication that somethinghas occurred that may affect the software application. Data events mayoccur, for example, when a user clicks a mouse to interact with theapplication, or when an error message is presented during processing ofthe application.

In some cases, XAF may be configured to track dependencies such thatdata evaluations and object graph constructions may be incrementallyupdated when data changes. For example, XAF may track dependencies indata such that a software application may be incrementally updated whenthe data is updated. In some embodiments, this incremental updating maybe carried out automatically by a XAF engine (e.g. the data flow engineor update determining module 115).

Thus, in some embodiments, data model data 121 may comprises aschematized XAF application description. This XAF applicationdescription may, in turn, be interpreted by the XAF engine (or updatedetermining module 115). Moreover, in some cases, at least one of thereal-time incremental editors 110A/110B may be instantiated based on aXAF application description. It should be noted that while XAF enginesand XAF application descriptions are provided as examples, any type offunctional application description language or functional applicationdescription language engine may be used.

Method 200 includes an act of updating the UI in real-time based on thedetermined edits to the data model data (act 240). For example, runtimemodel interpreter 130 may receive UI model updates, interpret thosemodel updates in real-time (or substantially real-time) and send the UIupdates 131 back to the editor(s). These changes may be applied to theUI(s) dynamically in real-time, without stopping or recompiling therunning UI. In some cases, only the minimal set of controls andproperties (or other elements) are updated based on determined datadependencies. Accordingly, if update determining module 115 (or a dataflow engine) determines that the determined data changes to element A,for example, affect elements C, D and F based on determined datadependencies, only elements A, C, D and F will be updated while theother elements will be left alone.

In instances where update determining module 115 comprises a data flowengine, the data flow engine may be configured to supporttransformations of collections, records and atoms (and any other formsof data model data) as well as track dependencies across data model dataitems. By tracking such data dependencies, the minimal set of elementsto be changed may be discovered and other elements may be leftunchanged. In another embodiment, a UI model interpreter may beinstantiated to perform each the following steps in real-time: receive adeclaratively defined UI model, interpret the UI model via functionaltransformation using the data flow engine and present the resulting UIto the user.

Returning to FIG. 2, method 200 includes an act of presenting theupdated UI in essentially real-time without losing state information inthe resultant UI (act 250). For example, running application 135 maypresent the visualized results of the updated UI 111 in essentiallyreal-time without losing state information in the UI. Thus, if a userhad previously selected a given element, that element would still beselected after the updates were dynamically applied. Moreover, it shouldbe noted that wherever the terms real-time, essentially real-time orsubstantially real-time appear, these terms are referring to a shorttime frame and not to an instantaneous event. Accordingly, even inreal-time, a delay may occur between the time an input is received andwhen that input is applied.

One example of displaying the visualized results of the updated UI maybe shown in environment 400 of FIG. 4. Environment 400 includes aneditor and a corresponding UI shown at two different times (i.e. editorat time 1 (T1) 410 with corresponding UI at T2 411 and editor at time 2(T2) 420 with corresponding UI at T2 421). Editor at T1 includes a UI411 that has three items: input box 412, button 413 andselectable/draggable object 414. A user may indicate thatselectable/draggable object 414 is to be moved to a position above inputbox 412, that button 413 is to be deleted and that a menu box is to beadded. These changes may be applied incrementally or may be applied as agroup. Accordingly, although not shown in FIG. 4, in the above example auser may see each edit incrementally applied to the UI essentially assoon as the edit has been input by the user. At time T2, UI 421 mayappear with each of the above changes applied: selectable/draggableobject 424 has been moved to its new location, input box 422 has beenmoved to a lower position, button 413 has been deleted and menu 425 hasbeen added to the UI. This example is merely intended to show oneexample of how UI elements may be updated in real-time. In otherembodiments, different elements, different applications and differentnumbers of elements may be used.

In this manner, a user's edits may be analyzed to determine whichchanges are to be made to the user interface (or other softwareapplication) and applied to the user interface in real-time, while theUI is running, without stopping the application and without losing stateinformation. In a similar vein, the potential results of a user's editsmay be previewed within an editor, as explained below with regard tomethod 300 of FIG. 3.

FIG. 3 illustrates a flowchart of a method 300 for presenting a previewof the potential results of a user edit to data model data. The method300 will now be described with frequent reference to the components anddata of environments 100 of FIGS. 1 and 500 of FIG. 5.

Method 300 includes an act of instantiating a real-time incrementaleditor configured to receive editing inputs that are to be applied todata of a data model, wherein the data model data declaratively definesa UI model that drives the behavior of a corresponding UI based on theUI model (act 310). For example, a computer system may instantiateincremental real-time editor A (110A) which may be configured to receiveediting inputs 106 that are to be applied to data 121 of data model 120.As described above, data model data 121 declaratively defines a UI modelthat drives the behavior of UI 111 which is based on the UI model.Because the UI model is declaratively defined, simple changes to themodel data can be applied in real-time without having to recompile oreven stop a running software application that is based on the datamodel.

Method 300 further includes an act of receiving an input from a user atthe instantiated editor, the input indicating one or more edits that areto be applied to a running software application (act 320). For example,editor B (110B) may receive editing input 106 from user 105 indicatingone or more desired edits that are to be made to the UI. These edits maycomprise text edits, graphical edits or any other type of changes ormodifications that can be made to UI 111.

Method 300 also includes an act of determining, based on the receiveduser input, which changes are to be made to the data model data to enactthe desired changes in the running software application (act 330). Forexample, update determining module 115 may determine, based on receivedediting inputs 106 (and/or determined changes 113), which UI modelupdates 123 are to be made to data model data 121 (upon which UI 111 isbuilt) to enact the desired changes in the UI. These UI model updatesmay comprise, for example, an indication of which elements are to bechanged and by how much.

Method 300 includes an act of previewing the determined changes inreal-time on the running application (act 340). For example, runningapplication 135 may be configured to preview the determined UI modelupdates 123 which are based on determined changes 113 which are in turnbased on editing input 106. These UI model updates may be applied to arunning UI by runtime model interpreter 130 which interprets the UImodel (and changes thereto) at runtime and provides the actual UIupdates which are displayed in the UI (111) of the running application(135). Thus, as a user applies inputs, the results of those inputs maybe displayed in the running application.

In some embodiments, user 105 may select an element of the data model(i.e. a UI element) in the editor and the editor may display, inreal-time, a highlight around each corresponding instance of theselected element on the running application. Accordingly, as shown inFIG. 5, editor 510 may present UI 515 to the user with various elementsincluding a menu, input box and other items A, B, C and D. User 105 mayselect item B (i.e. selected item 516) and, upon selection, anycorresponding items in the running application that are implementedbased on item B may be highlighted. Thus, in running application 520,items B1, B2 and B3, each of which implement item B of UI 515, arehighlighted. In this manner, the user can easily look at the runningapplication and identify each of the items or areas where the selecteditem is being used. This can be helpful in debugging the runningapplication. The other UI items of the running application (i.e. menu521, item A 522A, item C 522C, item D 522D and input box 523 are nothighlighted unless or until the item is selected in the editor.

The selected item may be identified within the running application usinga query. Editor 510 may be configured to construct a query that is usedto query for each instance of the selected element. The editor can thenidentify the items based on the response to the query. In someembodiments, a host environment may be configured to display thehighlighting around each corresponding instance of the selected elementon the running application. Additionally or alternatively, user inputsmay be received at the editor that result in a new feature being addedto the running software application. In such cases, the new features maybe dynamically added to the running software application in real-time.

Accordingly, an environment may be provided in which a user may select aUI (or other) item and each corresponding instance of that selected itemwill be highlighted in the running application, without stopping and/orrestarting the application. Moreover, a development environment may beprovided where a user's editing inputs are analyzed to determine whichchanges are to be made to the user interface (or other softwareapplication) and are applied to the user interface in real-time, whilethe UI is running, without stopping the application and without losingstate information.

The present invention may be embodied in other specific forms withoutdeparting from its spirit or essential characteristics. The describedembodiments are to be considered in all respects only as illustrativeand not restrictive. The scope of the invention is, therefore, indicatedby the appended claims rather than by the foregoing description. Allchanges which come within the meaning and range of equivalency of theclaims are to be embraced within their scope.

We claim:
 1. At a computer system that includes one or more processorsand system memory, a method for providing a real-time incremental editorfor enacting changes to user interface (UI) elements of an active UI,the method comprising: presenting a first UI of an executing applicationprogram based on a UI model that includes declarative model data thatdrives the behavior of the first UI, the UI model including particulardeclarative model data that declaratively defines a visual appearance ofone or more UI elements of the first UI, each of the one or more UIelements being an instance of the particular declarative model data; andconcurrent to presenting the first UI of the application program:presenting a second UI of a real-time incremental editor that isseparate from the application program and that is configured to receiveone or more editing inputs that are to be applied to the particulardeclarative model data of the UI model, to edit the first UI of theapplication program while the application program is executing;receiving a first editing user input at the second UI of the real-timeincremental editor, the first editing input selecting the particulardeclarative model data that declaratively defines the one or more UIelements; based on selection of the particular declarative model datawithin the real-time incremental editor, visually distinguishing each ofthe one or more UI elements within the first UI as being selected at thesecond UI of the real-time incremental editor; receiving a secondediting user input at the second UI of the real-time incremental editor,the second editing user input providing one or more changes to theparticular declarative model data corresponding to the one or more UIelements, in order to enact one or more desired edits to each of the oneor more UI elements; and updating the first UI to reflect the one ormore desired edits to the one or more UI elements, including alteringthe visual appearance of each of the one or more UI elements based onthe one or more changes to the particular declarative model datacorresponding to the one or more UI elements.
 2. The method as recitedin claim 1, wherein visually distinguishing each of the one or more UIelements within the first UI as being selected at the second UIcomprises drawing a highlight around each of the one or more UI elementsat the first UI.
 3. The method as recited in claim 1, wherein thedeclarative model data comprises a schematized extensible markuplanguage application foundation (XAF) application description.
 4. Themethod as recited in claim 1, wherein the declarative model data isdivided into chunks based on corresponding portions of a UI tree.
 5. Themethod as recited in claim 1, further comprising, based on the firstediting user input, constructing a query that is used to query for eachinstance of a UI element corresponding to the particular declarativemodel data.
 6. The method as recited in claim 1, further comprising:receiving a third editing user input at the second UI of the real-timeincremental editor that result in a new feature being added to theapplication program; and dynamically adding the new feature to theapplication program in real-time.
 7. The method as recited in claim 1,wherein updating the first UI to reflect the one or more desired editsto the one or more UI elements comprises previewing one or more changesto the one or more UI elements.
 8. One or more hardware storage deviceshaving stored thereon computer-executable instructions that, whenexecuted by one or more hardware processors of a computer system, causethe computer system to provide a real-time incremental editor forenacting changes to user interface (UI) elements of an active UI,including the following: presenting a first UI of an executingapplication program based on a UI model that includes declarative modeldata that drives the behavior of the first UI, the UI model includingparticular declarative model data that declaratively defines a visualappearance of one or more UI elements of the first UI, each of the oneor more UI elements being an instance of the particular declarativemodel data; and concurrent to presenting the first UI of the applicationprogram: presenting a second UI of a real-time incremental editor thatis separate from the application program and that is configured toreceive one or more editing inputs that are to be applied to theparticular declarative model data of the UI model, to edit the first UIof the application program while the application program is executing;receiving a first editing user input at the second UI of the real-timeincremental editor, the first editing input selecting the particulardeclarative model data that declaratively defines the one or more UIelements; based on selection of the particular declarative model datawithin the real-time incremental editor, visually distinguishing each ofthe one or more UI elements within the first UI as being selected at thesecond UI of the real-time incremental editor; receiving a secondediting user input at the second UI of the real-time incremental editor,the second editing user input providing one or more changes to theparticular declarative model data corresponding to the one or more UIelements, in order to enact one or more desired edits to each of the oneor more UI elements; and updating the first UI to reflect the one ormore desired edits to the one or more UI elements, including alteringthe visual appearance of each of the one or more UI elements based onthe one or more changes to the particular declarative model datacorresponding to the one or more UI elements.
 9. The one or morehardware storage devices as recited in claim 8, wherein visuallydistinguishing each of the one or more UI elements within the first UIas being selected at the second UI comprises drawing a highlight aroundeach of the one or more UI elements at the first UI.
 10. The one or morehardware storage devices as recited in claim 8, wherein the declarativemodel data comprises a schematized extensible markup languageapplication foundation (XAF) application description.
 11. The one ormore hardware storage devices as recited in claim 8, wherein thedeclarative model data is divided into chunks based on correspondingportions of a UI tree.
 12. The one or more hardware storage devices asrecited in claim 8, further comprising, based on the first editing userinput, constructing a query that is used to query for each instance of aUI element corresponding to the particular declarative model data. 13.The one or more hardware storage devices as recited in claim 8, furthercomprising: receiving a third editing user input at the second UI of thereal-time incremental editor that result in a new feature being added tothe application program; and dynamically adding the new feature to theapplication program in real-time.
 14. The one or more hardware storagedevices as recited in claim 8, wherein updating the first UI to reflectthe one or more desired edits to the one or more UI elements comprisespreviewing one or more changes to the one or more UI elements.
 15. Acomputer system, comprising: one or more hardware processors; and one ormore storage devices having stored thereon computer-executableinstructions that, when executed by the one or more hardware processors,cause the computer system to provide a real-time incremental editor forenacting changes to user interface (UI) elements of an active UI,including the following: presenting a first UI of an executingapplication program based on a UI model that includes declarative modeldata that drives the behavior of the first UI, the UI model includingparticular declarative model data that declaratively defines a visualappearance of one or more UI elements of the first UI, each of the oneor more UI elements being an instance of the particular declarativemodel data; and concurrent to presenting the first UI of the applicationprogram: presenting a second UI of a real-time incremental editor thatis separate from the application program and that is configured toreceive one or more editing inputs that are to be applied to theparticular declarative model data of the UI model, to edit the first UIof the application program while the application program is executing;receiving a first editing user input at the second UI of the real-timeincremental editor, the first editing input selecting the particulardeclarative model data that declaratively defines the one or more UIelements; based on selection of the particular declarative model datawithin the real-time incremental editor, visually distinguishing each ofthe one or more UI elements within the first UI as being selected at thesecond UI of the real-time incremental editor; receiving a secondediting user input at the second UI of the real-time incremental editor,the second editing user input providing one or more changes to theparticular declarative model data corresponding to the one or more UIelements, in order to enact one or more desired edits to each of the oneor more UI elements; and updating the first UI to reflect the one ormore desired edits to the one or more UI elements, including alteringthe visual appearance of each of the one or more UI elements based onthe one or more changes to the particular declarative model datacorresponding to the one or more UI elements.
 16. The computer system asrecited in claim 15, wherein visually distinguishing each of the one ormore UI elements within the first UI as being selected at the second UIcomprises drawing a highlight around each of the one or more UI elementsat the first UI.
 17. The computer system as recited in claim 15, whereinthe declarative model data comprises a schematized extensible markuplanguage application foundation (XAF) application description.
 18. Thecomputer system as recited in claim 15, wherein the declarative modeldata is divided into chunks based on corresponding portions of a UItree.
 19. The computer system as recited in claim 15, furthercomprising, based on the first editing user input, constructing a querythat is used to query for each instance of a UI element corresponding tothe particular declarative model data.
 20. The computer system asrecited in claim 15, further comprising: receiving a third editing userinput at the second UI of the real-time incremental editor that resultin a new feature being added to the application program; and dynamicallyadding the new feature to the application program in real-time.